// 引入ASP.NET Core MVC命名空间
using Microsoft.AspNetCore.Mvc;
// 引入数据访问层命名空间
using RestfulApi.Data;
// 引入模型命名空间
using RestfulApi.Models;

// 定义控制器命名空间
namespace RestfulApi.Controllers
{
    // 定义API路由前缀为"api/Colors"
    [Route("api/[controller]/[action]")]
    // 标记为API控制器，启用API特定行为
    [ApiController]
    // 颜色控制器类，继承自ControllerBase基类
    public class ColorsController : ControllerBase
    {
        // 声明颜色仓储私有字段
        private readonly ColorRepository _repository;

        // 控制器构造函数，初始化仓储对象
        public ColorsController()
        {
            // 实例化颜色仓储
            _repository = new ColorRepository();
        }

        // GET: api/Colors/GetColors - 获取所有颜色
        [HttpGet]
        // 返回颜色集合的操作方法
        public ActionResult<IEnumerable<Color>> GetColors()
        {
            // 返回HTTP 200 OK状态码和所有颜色数据
            return Ok(_repository.GetAll());
        }

        // GET: api/Colors/GetColor/5 - 获取指定ID的颜色
        [HttpGet("{id}")]
        // 返回单个颜色的操作方法
        // 参数 id: 要获取的颜色ID
        public ActionResult<Color> GetColor(int id)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 返回HTTP 200 OK状态码和颜色数据
            return Ok(color);
        }

        // POST: api/Colors/FilterColors - 根据条件筛选颜色
        [HttpPost]
        // 筛选颜色的操作方法
        // 参数 filter: 颜色过滤条件(从请求体获取)
        public ActionResult<IEnumerable<Color>> FilterColors(ColorFilter filter)
        {
            // 如果过滤条件为空，返回400 Bad Request状态码
            if (filter == null)
            {
                return BadRequest();
            }

            // 返回HTTP 200 OK状态码和筛选后的颜色数据
            return Ok(_repository.GetFiltered(filter));
        }

        // POST: api/Colors/CreateColor - 创建新颜色
        [HttpPost]
        // 创建颜色的操作方法
        // 参数 color: 要创建的颜色对象(从请求体获取)
        public ActionResult<Color> CreateColor(Color color)
        {
            // 如果请求体为空，返回400 Bad Request状态码
            if (color == null)
            {
                return BadRequest();
            }

            // 添加颜色到仓储并获取创建后的颜色(包含新ID)
            var createdColor = _repository.Add(color);
            
            // 返回201 Created状态码，包含新创建资源的位置和数据
            return CreatedAtAction(nameof(GetColor), new { id = createdColor.Id }, createdColor);
        }

        // POST: api/Colors/CreateBatch - 批量创建颜色
        [HttpPost]
        // 批量创建颜色的操作方法
        // 参数 request: 批量操作请求(从请求体获取)
        public ActionResult<IEnumerable<Color>> CreateBatch(ColorBatchRequest request)
        {
            // 如果请求体为空或颜色列表为空，返回400 Bad Request状态码
            if (request == null || request.Colors == null || !request.Colors.Any())
            {
                return BadRequest("请求无效或颜色列表为空");
            }

            // 验证操作类型
            if (request.Operation != "create")
            {
                return BadRequest("不支持的操作类型");
            }

            // 批量添加颜色
            var createdColors = _repository.AddBatch(request.Colors);
            
            // 返回HTTP 200 OK状态码和创建的颜色数据
            return Ok(createdColors);
        }

        // PUT: api/Colors/UpdateColor/5 - 更新指定ID的颜色
        [HttpPut("{id}")]
        // 更新颜色的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 color: 更新后的颜色对象(从请求体获取)
        public IActionResult UpdateColor(int id, Color color)
        {
            // 如果路由ID与颜色ID不匹配，返回400 Bad Request状态码
            if (id != color.Id)
            {
                return BadRequest();
            }

            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果颜色不存在，返回404 Not Found状态码
            if (!success)
            {
                return NotFound();
            }

            // 更新成功，返回204 No Content状态码
            return NoContent();
        }

        // DELETE: api/Colors/DeleteColor/5 - 删除指定ID的颜色
        [HttpDelete("{id}")]
        // 删除颜色的操作方法
        // 参数 id: 要删除的颜色ID
        public IActionResult DeleteColor(int id)
        {
            // 尝试删除颜色并获取操作结果
            var success = _repository.Delete(id);
            
            // 如果颜色不存在，返回404 Not Found状态码
            if (!success)
            {
                return NotFound();
            }

            // 删除成功，返回204 No Content状态码
            return NoContent();
        }

        // POST: api/Colors/UpdateRgbValue/5 - 更新指定颜色的RGB值
        [HttpPost("{id}")]
        // 更新颜色RGB值的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 rgbValue: 更新后的RGB值(从请求体获取)
        public IActionResult UpdateRgbValue(int id, RgbValue rgbValue)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新RGB值
            color.RgbValue = rgbValue;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色RGB值失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }

        // POST: api/Colors/UpdateCategory/5 - 更新指定颜色的分类
        [HttpPost("{id}")]
        // 更新颜色分类的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 category: 更新后的分类(从请求体获取)
        public IActionResult UpdateCategory(int id, ColorCategory category)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新分类
            color.Category = category;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色分类失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
        
        // POST: api/Colors/UpdateMetadata/5 - 更新指定颜色的元数据
        [HttpPost("{id}")]
        // 更新颜色元数据的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 metadata: 更新后的元数据(从请求体获取)
        public IActionResult UpdateMetadata(int id, ColorMetadata metadata)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新元数据
            color.Metadata = metadata;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色元数据失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
        
        // POST: api/Colors/UpdateColorUsage/5 - 更新指定颜色的使用情况
        [HttpPost("{id}")]
        // 更新颜色使用情况的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 usage: 更新后的使用情况(从请求体获取)
        public IActionResult UpdateColorUsage(int id, ColorUsage usage)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新使用情况
            color.Metadata.Usage = usage;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色使用情况失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
        
        // POST: api/Colors/UpdateIndustryDetails/5 - 更新指定颜色的行业详情
        [HttpPost("{id}")]
        // 更新颜色行业详情的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 details: 更新后的行业详情(从请求体获取)
        public IActionResult UpdateIndustryDetails(int id, ColorIndustryDetails details)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新行业详情（嵌套4层）
            color.Metadata.Usage.Industry.Details = details;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色行业详情失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
        
        // POST: api/Colors/UpdateHistoricalData/5 - 更新指定颜色的历史数据
        [HttpPost("{id}")]
        // 更新颜色历史数据的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 historicalData: 更新后的历史数据列表(从请求体获取)
        public IActionResult UpdateHistoricalData(int id, List<ColorHistoricalData> historicalData)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新历史数据（嵌套5层）
            color.Metadata.Usage.Industry.Details.HistoricalData = historicalData;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色历史数据失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
        
        // POST: api/Colors/UpdateCompetitorAnalysis/5 - 更新指定颜色的竞争对手分析
        [HttpPost("{id}")]
        // 更新颜色竞争对手分析的操作方法
        // 参数 id: 路由中的颜色ID
        // 参数 competitorAnalysis: 更新后的竞争对手分析(从请求体获取)
        public IActionResult UpdateCompetitorAnalysis(int id, ColorCompetitorAnalysis competitorAnalysis)
        {
            // 从仓储中获取指定ID的颜色
            var color = _repository.GetById(id);

            // 如果颜色不存在，返回404 Not Found状态码
            if (color == null)
            {
                return NotFound();
            }

            // 更新竞争对手分析（另一个分支的嵌套5层）
            color.Metadata.Trend.Forecast.MarketAnalysis.CompetitorAnalysis = competitorAnalysis;
            
            // 尝试更新颜色并获取操作结果
            var success = _repository.Update(color);
            
            // 如果更新失败，返回500 Internal Server Error状态码
            if (!success)
            {
                return StatusCode(500, "更新颜色竞争对手分析失败");
            }

            // 更新成功，返回200 OK状态码和更新后的颜色数据
            return Ok(color);
        }
    }
}